home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Highlands / Highlands Gigantic.rmv next >
Encoding:
Text File  |  2001-09-27  |  51.9 KB  |  1,561 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Highlands Gigantic.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 9/06/01 6:46p $
  11. // $Revision: 22 $
  12. // $Revision: 22 $
  13. //   Adjusted Angle between team members 
  14. // $Revision:
  15. //  Revision: 13 Lowered elevation, added neutrals, pushed players outward,
  16. //               lowered player outer radius, increased tree %, reduced
  17. //               forest free radius, reduced resource to edge distance
  18. //  Revision: 14 Used Highlands Small as the foundation.  Increased Neutral
  19. //               islands and percent land
  20. //  Revision: 15 revised for miniaturization 
  21. //  Revision: 16 Elevation 
  22. //  Revision: 17 Revised # of resources 3 by 3
  23. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  24. //  Revision: 19 General Adjustments
  25. //  Revision: 22 Design Adjustments 
  26. //  Revision: 23 Reduced Resources
  27. //  Revision: 24 Added Chance of steep cliffs 
  28. //  Revision: 25 Two forage sites for Prehistoric Start
  29. //  Revision: 26 Evened-out resource distribution 
  30. //  Revision: 26b Created neutral berry bushes for Prehistoric starts 
  31. //  Revision: 26h Increased ally/resource distance 
  32. //  Revision: 28 Moved resources 2 tiles further from Capitol
  33. //  Revision: 29 Added gold and iron to 5+ player maps
  34. //
  35. //////////////////////////////////////////////////////////////////////
  36.  
  37. #if            NOTDEFINED(HIGHLANDS_GIGANTIC_RMV)
  38. #define        (HIGHLANDS_GIGANTIC_RMV,1)
  39.  
  40. //////////////////////////////////////////////////////////////////////
  41. // Definitions we are required to define for highlands maps
  42. //////////////////////////////////////////////////////////////////////
  43.  
  44. ResourcePlacementLimit (Gold,     8,    16)
  45. ResourcePlacementLimit (Steel,     8,     16)
  46. ResourcePlacementLimit (Stone,     8,     16)
  47. ResourcePlacementLimit (Berry,     7,     12)
  48. ResourcePlacementLimit (Fish,     1,    50)
  49. ResourcePlacementLimit (Tree,     3,     6)
  50. ResourcePlacementLimit (Animal,     7,     15)
  51.  
  52. #if Is2Players
  53. //////////////////////////////////////////////////////////////////////
  54. // 2 PLAYERS...
  55. //////////////////////////////////////////////////////////////////////
  56.  
  57. //////////////////////////////////////////////////////////////////////
  58. // terrain definitions
  59. #if        PERCENT(80)
  60.   #define        (kMaxIntElevation,            10)
  61. #else
  62.   #define        (kMaxIntElevation,            16)
  63. #endif
  64.  
  65. #define        (kElevationScale,                Between(1, 1))
  66. #define        (kHeightMapChaos,                Between(30, 30))
  67.                                             
  68. #define        (kMinimumStartPositionToMapEdge    5)
  69. #define        (kOuterPushFromMapCenter        25)
  70. #define        (kInnerPushFromMapCenter         0)    
  71.     
  72. #define        (kConvergentSampleSize,            3) 
  73. #define        (kConvergentThreshold,            15)            
  74.  
  75. //////////////////////////////////////////////////////////////////////
  76. // player definitions
  77. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  78. #define        (kPlayerInnerRadius,            0.6)
  79. #define        (kPlayerOuterRadius,            0.95)
  80. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  81. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  82. #define        (kPlayerLandChaos,            0.8)
  83. #define        (kPlayerLandClumps,            Between(2, 2))
  84. #define        (kPlayerFlatChaos,            0.8)
  85. #define        (kPlayerFlatClumps,            Between(1, 2))
  86. #define        (kPlayerTreePercentage,            0.03)
  87.  
  88.  
  89. //////////////////////////////////////////////////////////////////////
  90. // inner neutral definitions
  91. #define        (kNeutralInnerRadius,            0.2)
  92. #define        (kNeutralOuterRadius,            0.5)
  93. #define        (kNeutralOptimalFactor,            0.7)
  94. #define        (kNumInnerNeutrals,                 Between(22, 22))
  95. #define        (kInnerNeutralPercentLand,        0.25)
  96. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  97. #define        (kInnerNeutralTreePercentage,          0.08)
  98. #define        (kInnerNeutralLandChaos,        0.8)
  99. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  100. #define        (kInnerNeutralFlatChaos,        0.8)
  101. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  102.  
  103.  
  104. //////////////////////////////////////////////////////////////////////
  105. // outer neutral definitions
  106. #define        (kNumOuterNeutrals,            Between(66, 66))
  107. #define        (kOuterNeutralPercentLand,        0.73)
  108. #define        (kOuterNeutralPercentFlat,        0.85)
  109. #define        (kOuterNeutralTreePercentage,          0.07)
  110. #define        (kOuterNeutralLandChaos,        0.8)
  111. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  112. #define        (kOuterNeutralFlatChaos,        0.8)
  113. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  114.  
  115.  
  116. //////////////////////////////////////////////////////////////////////
  117. // resource definitions
  118. #define        (kMaxResourceElevation,            3)
  119. #define        (kResourceToEdgeDistance,        2)
  120. #define        (kResourceToWaterDistance,        3)
  121.  
  122. #define        (kAnimalPerPlayer,            0)
  123. #define        (kAnimalPerNeutral,            0)
  124.  
  125. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  126.   #define  (kBerryPerPlayer,    1) 
  127.   #define  (kBerryPerNeutral,      6)
  128. #else
  129.   #define  (kBerryPerPlayer,    1)
  130.   #define  (kBerryPerNeutral,      0)
  131. #endif 
  132.  
  133.  
  134. #define        (kFishPerPlayer,                0)
  135. #define        (kFishPerNeutral,                0)
  136.  
  137. #define        (kGoldPerPlayer,                1)
  138. #define        (kGoldPerNeutral,                10)
  139.  
  140. #define        (kOilPerPlayer,                0)
  141. #define        (kOilPerNeutral,                0)
  142.  
  143. #define        (kSteelPerPlayer,                1)
  144. #define        (kSteelPerNeutral,            10)
  145.  
  146. #define        (kStonePerPlayer,                1)
  147. #define        (kStonePerNeutral,            4)
  148.  
  149. #define        (kTreePerPlayer,                1)
  150. #define        (kTreePerNeutral,                0)
  151.  
  152.  
  153. //////////////////////////////////////////////////////////////////////
  154. // forest definitions
  155. #define        (kForestFreeRadius,                8.0)
  156. #define        (kForestsPerPlayer,                2)
  157. #define        (kForestChaosLevel,                1)
  158. #define        (kMaxClumpsPerForest,                  2)
  159.  
  160. #elif Is3Players
  161. //////////////////////////////////////////////////////////////////////
  162. // 3 PLAYERS...
  163. //////////////////////////////////////////////////////////////////////
  164.  
  165. //////////////////////////////////////////////////////////////////////
  166. // terrain definitions
  167. #if        PERCENT(80)
  168.   #define        (kMaxIntElevation,            10)
  169. #else
  170.   #define        (kMaxIntElevation,            16)
  171. #endif
  172.  
  173. #define        (kElevationScale,                Between(1, 1))
  174. #define        (kHeightMapChaos,                Between(30, 30))
  175.                                             
  176. #define        (kMinimumStartPositionToMapEdge    5)
  177. #define        (kOuterPushFromMapCenter        25)
  178. #define        (kInnerPushFromMapCenter         0)    
  179.     
  180. #define        (kConvergentSampleSize,            32) 
  181. #define        (kConvergentThreshold,            8)            
  182.                                             
  183. //////////////////////////////////////////////////////////////////////
  184. // player definitions
  185. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  186. #define        (kPlayerInnerRadius,            0.6)
  187. #define        (kPlayerOuterRadius,            0.95)
  188. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  189. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  190. #define        (kPlayerLandChaos,            0.8)
  191. #define        (kPlayerLandClumps,            Between(2, 2))
  192. #define        (kPlayerFlatChaos,            0.8)
  193. #define        (kPlayerFlatClumps,            Between(1, 2))
  194. #define        (kPlayerTreePercentage,            0.03)
  195.  
  196.  
  197. //////////////////////////////////////////////////////////////////////
  198. // inner neutral definitions
  199. #define        (kNeutralInnerRadius,            0.2)
  200. #define        (kNeutralOuterRadius,            0.5)
  201. #define        (kNeutralOptimalFactor,            0.7)
  202. #define        (kNumInnerNeutrals,            Between(22, 22))
  203. #define        (kInnerNeutralPercentLand,        0.24)
  204. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  205. #define        (kInnerNeutralTreePercentage,          0.08)
  206. #define        (kInnerNeutralLandChaos,        0.8)
  207. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  208. #define        (kInnerNeutralFlatChaos,        0.8)
  209. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  210.  
  211. //////////////////////////////////////////////////////////////////////
  212. // outer neutral definitions
  213. #define        (kNumOuterNeutrals,            Between(64, 64))
  214. #define        (kOuterNeutralPercentLand,        0.72)
  215. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  216. #define        (kOuterNeutralTreePercentage,          0.07)
  217. #define        (kOuterNeutralLandChaos,        0.8)
  218. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  219. #define        (kOuterNeutralFlatChaos,        0.8)
  220. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  221.  
  222. //////////////////////////////////////////////////////////////////////
  223. // resource definitions
  224. #define        (kMaxResourceElevation,            3)
  225. #define        (kResourceToEdgeDistance,        2)
  226. #define        (kResourceToWaterDistance,        4)
  227.  
  228. #define        (kAnimalPerPlayer,            0)
  229. #define        (kAnimalPerNeutral,            0)
  230.  
  231. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  232.   #define  (kBerryPerPlayer,    1) 
  233.   #define  (kBerryPerNeutral,      9)
  234. #else
  235.   #define  (kBerryPerPlayer,    1)
  236.   #define  (kBerryPerNeutral,      0)
  237. #endif 
  238.  
  239. #define        (kFishPerPlayer,                0)
  240. #define        (kFishPerNeutral,                0)
  241.  
  242. #define        (kGoldPerPlayer,                1)
  243. #define        (kGoldPerNeutral,                14)
  244.  
  245. #define        (kOilPerPlayer,                0)
  246. #define        (kOilPerNeutral,                0)
  247.  
  248. #define        (kSteelPerPlayer,                1)
  249. #define        (kSteelPerNeutral,            14)
  250.  
  251. #define        (kStonePerPlayer,                1)
  252. #define        (kStonePerNeutral,            5)
  253.  
  254. #define        (kTreePerPlayer,                1)
  255. #define        (kTreePerNeutral,                0)
  256.  
  257.  
  258. //////////////////////////////////////////////////////////////////////
  259. // forest definitions
  260. #define        (kForestFreeRadius,                8.0)
  261. #define        (kForestsPerPlayer,                2)
  262. #define        (kForestChaosLevel,                1)
  263. #define        (kMaxClumpsPerForest,                  2)
  264.  
  265. #elif Is4Players
  266. //////////////////////////////////////////////////////////////////////
  267. // 4 PLAYERS...
  268. //////////////////////////////////////////////////////////////////////
  269.  
  270. //////////////////////////////////////////////////////////////////////
  271. // terrain definitions
  272. #if        PERCENT(80)
  273.   #define        (kMaxIntElevation,            10)
  274. #else
  275.   #define        (kMaxIntElevation,            16)
  276. #endif
  277.  
  278. #define        (kElevationScale,                Between(1, 1))
  279. #define        (kHeightMapChaos,                Between(30, 30))
  280.                                             
  281. #define        (kMinimumStartPositionToMapEdge    5)
  282. #define        (kOuterPushFromMapCenter        25)
  283. #define        (kInnerPushFromMapCenter         0)    
  284.     
  285. #define        (kConvergentSampleSize,            32) 
  286. #define        (kConvergentThreshold,            8)    
  287.                     
  288. //////////////////////////////////////////////////////////////////////
  289. // player definitions
  290. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  291. #define        (kPlayerInnerRadius,            0.6)
  292. #define        (kPlayerOuterRadius,            0.95)
  293. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  294. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  295. #define        (kPlayerLandChaos,            0.8)
  296. #define        (kPlayerLandClumps,            Between(2, 2))
  297. #define        (kPlayerFlatChaos,            0.8)
  298. #define        (kPlayerFlatClumps,            Between(1, 2))
  299. #define        (kPlayerTreePercentage,            0.03)
  300.  
  301.  
  302. //////////////////////////////////////////////////////////////////////
  303. // inner neutral definitions
  304. #define        (kNeutralInnerRadius,            0.2)
  305. #define        (kNeutralOuterRadius,            0.5)
  306. #define        (kNeutralOptimalFactor,            0.7)
  307. #define        (kNumInnerNeutrals,                 Between(22, 22))
  308. #define        (kInnerNeutralPercentLand,        0.23)
  309. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  310. #define        (kInnerNeutralTreePercentage,          0.08)
  311. #define        (kInnerNeutralLandChaos,        0.8)
  312. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  313. #define        (kInnerNeutralFlatChaos,        0.8)
  314. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  315.  
  316. //////////////////////////////////////////////////////////////////////
  317. // outer neutral definitions
  318. #define        (kNumOuterNeutrals,            Between(62, 62))
  319. #define        (kOuterNeutralPercentLand,        0.72)
  320. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  321. #define        (kOuterNeutralTreePercentage,          0.07)
  322. #define        (kOuterNeutralLandChaos,        0.8)
  323. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  324. #define        (kOuterNeutralFlatChaos,        0.8)
  325. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  326.  
  327. //////////////////////////////////////////////////////////////////////
  328. // resource definitions
  329. #define        (kMaxResourceElevation,            3)
  330. #define        (kResourceToEdgeDistance,        2)
  331. #define        (kResourceToWaterDistance,        4)
  332.  
  333. #define        (kAnimalPerPlayer,            0)
  334. #define        (kAnimalPerNeutral,            0)
  335.  
  336. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  337.   #define  (kBerryPerPlayer,    1) 
  338.   #define  (kBerryPerNeutral,      7)
  339. #else
  340.   #define  (kBerryPerPlayer,    1)
  341.   #define  (kBerryPerNeutral,      0)
  342. #endif 
  343.  
  344.  
  345. #define        (kFishPerPlayer,                0)
  346. #define        (kFishPerNeutral,                0)
  347.  
  348. #define        (kGoldPerPlayer,                1)
  349. #define        (kGoldPerNeutral,                16)
  350.  
  351. #define        (kOilPerPlayer,                0)
  352. #define        (kOilPerNeutral,                0)
  353.  
  354. #define        (kSteelPerPlayer,                1)
  355. #define        (kSteelPerNeutral,            16)
  356.  
  357. #define        (kStonePerPlayer,                1)
  358. #define        (kStonePerNeutral,            6)
  359.  
  360. #define        (kTreePerPlayer,                1)
  361. #define        (kTreePerNeutral,                0)
  362.  
  363.  
  364. //////////////////////////////////////////////////////////////////////
  365. // forest definitions
  366. #define        (kForestFreeRadius,                8.0)
  367. #define        (kForestsPerPlayer,                2)
  368. #define        (kForestChaosLevel,                1)
  369. #define        (kMaxClumpsPerForest,                  2)
  370.  
  371. #elif Is5Players
  372. //////////////////////////////////////////////////////////////////////
  373. // 5 PLAYERS...
  374. //////////////////////////////////////////////////////////////////////
  375.  
  376. //////////////////////////////////////////////////////////////////////
  377. // terrain definitions
  378. #if        PERCENT(80)
  379.   #define        (kMaxIntElevation,            10)
  380. #else
  381.   #define        (kMaxIntElevation,            16)
  382. #endif
  383.  
  384. #define        (kElevationScale,                Between(1, 1))
  385. #define        (kHeightMapChaos,                Between(30, 30))
  386.                                             
  387. #define        (kMinimumStartPositionToMapEdge    5)
  388. #define        (kOuterPushFromMapCenter        25)
  389. #define        (kInnerPushFromMapCenter         0)    
  390.     
  391. #define        (kConvergentSampleSize,            32) 
  392. #define        (kConvergentThreshold,            1)            
  393.                                             
  394. //////////////////////////////////////////////////////////////////////
  395. // player definitions
  396. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  397. #define        (kPlayerInnerRadius,            0.6)
  398. #define        (kPlayerOuterRadius,            0.95)
  399. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  400. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  401. #define        (kPlayerLandChaos,            0.8)
  402. #define        (kPlayerLandClumps,            Between(2, 2))
  403. #define        (kPlayerFlatChaos,            0.8)
  404. #define        (kPlayerFlatClumps,            Between(1, 2))
  405. #define        (kPlayerTreePercentage,            0.04)
  406.  
  407.  
  408. //////////////////////////////////////////////////////////////////////
  409. // inner neutral definitions
  410. #define        (kNeutralInnerRadius,            0.2)
  411. #define        (kNeutralOuterRadius,            0.5)
  412. #define        (kNeutralOptimalFactor,            0.7)
  413. #define        (kNumInnerNeutrals,                 Between(22, 22))
  414. #define        (kInnerNeutralPercentLand,        0.22)
  415. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  416. #define        (kInnerNeutralTreePercentage,          0.09)
  417. #define        (kInnerNeutralLandChaos,        0.8)
  418. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  419. #define        (kInnerNeutralFlatChaos,        0.8)
  420. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  421.  
  422.  
  423. //////////////////////////////////////////////////////////////////////
  424. // outer neutral definitions
  425. #define        (kNumOuterNeutrals,            Between(59, 59))
  426. #define        (kOuterNeutralPercentLand,        0.71)
  427. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  428. #define        (kOuterNeutralTreePercentage,          0.07)
  429. #define        (kOuterNeutralLandChaos,        0.8)
  430. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  431. #define        (kOuterNeutralFlatChaos,        0.8)
  432. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  433.  
  434. //////////////////////////////////////////////////////////////////////
  435. // resource definitions
  436. #define        (kMaxResourceElevation,            3)
  437. #define        (kResourceToEdgeDistance,        2)
  438. #define        (kResourceToWaterDistance,        4)
  439.  
  440. #define        (kAnimalPerPlayer,            0)
  441. #define        (kAnimalPerNeutral,            0)
  442.  
  443. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  444.   #define  (kBerryPerPlayer,    1) 
  445.   #define  (kBerryPerNeutral,      9)
  446. #else
  447.   #define  (kBerryPerPlayer,    1)
  448.   #define  (kBerryPerNeutral,      0)
  449. #endif 
  450.  
  451.  
  452. #define        (kFishPerPlayer,                0)
  453. #define        (kFishPerNeutral,                0)
  454.  
  455. #define        (kGoldPerPlayer,                1)
  456. #define        (kGoldPerNeutral,                18)
  457.  
  458. #define        (kOilPerPlayer,                0)
  459. #define        (kOilPerNeutral,                0)
  460.  
  461. #define        (kSteelPerPlayer,                1)
  462. #define        (kSteelPerNeutral,            18)
  463.  
  464. #define        (kStonePerPlayer,                1)
  465. #define        (kStonePerNeutral,            6)
  466.  
  467. #define        (kTreePerPlayer,                1)
  468. #define        (kTreePerNeutral,                0)
  469.  
  470.  
  471. //////////////////////////////////////////////////////////////////////
  472. // forest definitions
  473. #define        (kForestFreeRadius,                8.0)
  474. #define        (kForestsPerPlayer,                2)
  475. #define        (kForestChaosLevel,                1)
  476. #define        (kMaxClumpsPerForest,                  2)
  477.  
  478.  
  479. #elif Is6Players
  480. //////////////////////////////////////////////////////////////////////
  481. // 6 PLAYERS...
  482. //////////////////////////////////////////////////////////////////////
  483.  
  484. //////////////////////////////////////////////////////////////////////
  485. // terrain definitions
  486. #if        PERCENT(80)
  487.   #define        (kMaxIntElevation,            10)
  488. #else
  489.   #define        (kMaxIntElevation,            16)
  490. #endif
  491.  
  492. #define        (kElevationScale,                Between(1, 1))
  493. #define        (kHeightMapChaos,                Between(30, 30))
  494.                                             
  495. #define        (kMinimumStartPositionToMapEdge    5)
  496. #define        (kOuterPushFromMapCenter        25)
  497. #define        (kInnerPushFromMapCenter         0)    
  498.     
  499. #define        (kConvergentSampleSize,            32) 
  500. #define        (kConvergentThreshold,            1)    
  501.                                             
  502. //////////////////////////////////////////////////////////////////////
  503. // player definitions
  504. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  505. #define        (kPlayerInnerRadius,            0.6)
  506. #define        (kPlayerOuterRadius,            0.95)
  507. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  508. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  509. #define        (kPlayerLandChaos,            0.8)
  510. #define        (kPlayerLandClumps,            Between(2, 2))
  511. #define        (kPlayerFlatChaos,            0.8)
  512. #define        (kPlayerFlatClumps,            Between(1, 2))
  513. #define        (kPlayerTreePercentage,            0.04)
  514.  
  515.  
  516. //////////////////////////////////////////////////////////////////////
  517. // inner neutral definitions
  518. #define        (kNeutralInnerRadius,            0.2)
  519. #define        (kNeutralOuterRadius,            0.5)
  520. #define        (kNeutralOptimalFactor,            0.7)
  521. #define        (kNumInnerNeutrals,                 Between(22, 22))
  522. #define        (kInnerNeutralPercentLand,        0.21)
  523. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  524. #define        (kInnerNeutralTreePercentage,          0.09)
  525. #define        (kInnerNeutralLandChaos,        0.8)
  526. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  527. #define        (kInnerNeutralFlatChaos,        0.8)
  528. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  529.  
  530. //////////////////////////////////////////////////////////////////////
  531. // outer neutral definitions
  532. #define        (kNumOuterNeutrals,            Between(56, 56))
  533. #define        (kOuterNeutralPercentLand,        0.7)
  534. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  535. #define        (kOuterNeutralTreePercentage,          0.07)
  536. #define        (kOuterNeutralLandChaos,        0.8)
  537. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  538. #define        (kOuterNeutralFlatChaos,        0.8)
  539. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  540.  
  541. //////////////////////////////////////////////////////////////////////
  542. // resource definitions
  543. #define        (kMaxResourceElevation,            3)
  544. #define        (kResourceToEdgeDistance,        2)
  545. #define        (kResourceToWaterDistance,        4)
  546.  
  547. #define        (kAnimalPerPlayer,            0)
  548. #define        (kAnimalPerNeutral,            0)
  549.  
  550. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  551.   #define  (kBerryPerPlayer,    2)
  552. #else
  553.   #define  (kBerryPerPlayer,    1)
  554. #endif 
  555.  
  556. #define        (kBerryPerNeutral,            0)
  557.  
  558. #define        (kFishPerPlayer,                0)
  559. #define        (kFishPerNeutral,                0)
  560.  
  561. #define        (kGoldPerPlayer,                1)
  562. #define        (kGoldPerNeutral,                20)
  563.  
  564. #define        (kOilPerPlayer,                0)
  565. #define        (kOilPerNeutral,                0)
  566.  
  567. #define        (kSteelPerPlayer,                1)
  568. #define        (kSteelPerNeutral,            20)
  569.  
  570. #define        (kStonePerPlayer,                1)
  571. #define        (kStonePerNeutral,            6)
  572.  
  573. #define        (kTreePerPlayer,                1)
  574. #define        (kTreePerNeutral,                0)
  575.  
  576.  
  577. //////////////////////////////////////////////////////////////////////
  578. // forest definitions
  579. #define        (kForestFreeRadius,                8.0)
  580. #define        (kForestsPerPlayer,                2)
  581. #define        (kForestChaosLevel,                1)
  582. #define        (kMaxClumpsPerForest,                  2)
  583.  
  584.  
  585. #elif Is7Players
  586. //////////////////////////////////////////////////////////////////////
  587. // 7 PLAYERS...
  588. //////////////////////////////////////////////////////////////////////
  589.  
  590. //////////////////////////////////////////////////////////////////////
  591. // terrain definitions
  592. #if        PERCENT(80)
  593.   #define        (kMaxIntElevation,            10)
  594. #else
  595.   #define        (kMaxIntElevation,            16)
  596. #endif
  597.  
  598. #define        (kElevationScale,                Between(1, 1))
  599. #define        (kHeightMapChaos,                Between(30, 30))
  600.                                             
  601. #define        (kMinimumStartPositionToMapEdge    5)
  602. #define        (kOuterPushFromMapCenter        25)
  603. #define        (kInnerPushFromMapCenter         0)    
  604.     
  605. #define        (kConvergentSampleSize,            32) 
  606. #define        (kConvergentThreshold,            1)        
  607.                                             
  608. //////////////////////////////////////////////////////////////////////
  609. // player definitions
  610. #define        (kMaxAngleBetweenTeamMembers,          30.0)
  611. #define        (kPlayerInnerRadius,            0.6)
  612. #define        (kPlayerOuterRadius,            0.95)
  613. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  614. #define        (kPlayerPercentFlat,            Between(0.59, 0.59))
  615. #define        (kPlayerLandChaos,            0.8)
  616. #define        (kPlayerLandClumps,            Between(2, 2))
  617. #define        (kPlayerFlatChaos,            0.8)
  618. #define        (kPlayerFlatClumps,            Between(1, 2))
  619. #define        (kPlayerTreePercentage,            0.04)
  620.  
  621.  
  622. //////////////////////////////////////////////////////////////////////
  623. // inner neutral definitions
  624. #define        (kNeutralInnerRadius,            0.2)
  625. #define        (kNeutralOuterRadius,            0.5)
  626. #define        (kNeutralOptimalFactor,            0.7)
  627. #define        (kNumInnerNeutrals,                 Between(22, 22))
  628. #define        (kInnerNeutralPercentLand,        0.2)
  629. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  630. #define        (kInnerNeutralTreePercentage,          0.09)
  631. #define        (kInnerNeutralLandChaos,        0.8)
  632. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  633. #define        (kInnerNeutralFlatChaos,        0.8)
  634. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  635.  
  636. //////////////////////////////////////////////////////////////////////
  637. // outer neutral definitions
  638. #define        (kNumOuterNeutrals,            Between(54, 54))
  639. #define        (kOuterNeutralPercentLand,        0.67)
  640. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  641. #define        (kOuterNeutralTreePercentage,          0.07)
  642. #define        (kOuterNeutralLandChaos,        0.8)
  643. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  644. #define        (kOuterNeutralFlatChaos,        0.8)
  645. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  646.  
  647. //////////////////////////////////////////////////////////////////////
  648. // resource definitions
  649. #define        (kMaxResourceElevation,            3)
  650. #define        (kResourceToEdgeDistance,        2)
  651. #define        (kResourceToWaterDistance,        4)
  652.  
  653. #define        (kAnimalPerPlayer,            0)
  654. #define        (kAnimalPerNeutral,            0)
  655.  
  656. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  657.   #define  (kBerryPerPlayer,    2)
  658. #else
  659.   #define  (kBerryPerPlayer,    1)
  660. #endif 
  661.  
  662. #define        (kBerryPerNeutral,            0)
  663.  
  664. #define        (kFishPerPlayer,                0)
  665. #define        (kFishPerNeutral,                0)
  666.  
  667. #define        (kGoldPerPlayer,                1)
  668. #define        (kGoldPerNeutral,                21)
  669.  
  670. #define        (kOilPerPlayer,                0)
  671. #define        (kOilPerNeutral,                0)
  672.  
  673. #define        (kSteelPerPlayer,                1)
  674. #define        (kSteelPerNeutral,            21)
  675.  
  676. #define        (kStonePerPlayer,                1)
  677. #define        (kStonePerNeutral,            7)
  678.  
  679. #define        (kTreePerPlayer,                1)
  680. #define        (kTreePerNeutral,                0)
  681.  
  682.  
  683. //////////////////////////////////////////////////////////////////////
  684. // forest definitions
  685. #define        (kForestFreeRadius,                8.0)
  686. #define        (kForestsPerPlayer,                2)
  687. #define        (kForestChaosLevel,                1)
  688. #define        (kMaxClumpsPerForest,                  2)
  689.  
  690. #elif Is8Players
  691. //////////////////////////////////////////////////////////////////////
  692. // 8 PLAYERS...
  693. //////////////////////////////////////////////////////////////////////
  694.  
  695. //////////////////////////////////////////////////////////////////////
  696. // terrain definitions
  697. #if        PERCENT(80)
  698.   #define        (kMaxIntElevation,            10)
  699. #else
  700.   #define        (kMaxIntElevation,            16)
  701. #endif
  702.  
  703. #define        (kElevationScale,                Between(1, 1))
  704. #define        (kHeightMapChaos,                Between(30, 30))
  705.                                             
  706. #define        (kMinimumStartPositionToMapEdge    5)
  707. #define        (kOuterPushFromMapCenter        25)
  708. #define        (kInnerPushFromMapCenter         0)    
  709.     
  710. #define        (kConvergentSampleSize,            32) 
  711. #define        (kConvergentThreshold,            1)    
  712.                                             
  713. //////////////////////////////////////////////////////////////////////
  714. // player definitions
  715. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  716. #define        (kPlayerInnerRadius,            0.6)
  717. #define        (kPlayerOuterRadius,            0.95)
  718. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  719. #define        (kPlayerPercentFlat,            Between(.9, .9))
  720. #define        (kPlayerLandChaos,            0.8)
  721. #define        (kPlayerLandClumps,            Between(2, 2))
  722. #define        (kPlayerFlatChaos,            0.8)
  723. #define        (kPlayerFlatClumps,            Between(1, 2))
  724. #define        (kPlayerTreePercentage,            0.04)
  725.  
  726. //////////////////////////////////////////////////////////////////////
  727. // inner neutral definitions
  728. #define        (kNeutralInnerRadius,            0.2)
  729. #define        (kNeutralOuterRadius,            0.5)
  730. #define        (kNeutralOptimalFactor,            0.7)
  731. #define        (kNumInnerNeutrals,                 Between(22, 22))
  732. #define        (kInnerNeutralPercentLand,        0.19)
  733. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  734. #define        (kInnerNeutralTreePercentage,          0.09)
  735. #define        (kInnerNeutralLandChaos,        0.8)
  736. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  737. #define        (kInnerNeutralFlatChaos,        0.8)
  738. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  739.  
  740. //////////////////////////////////////////////////////////////////////
  741. // outer neutral definitions
  742. #define        (kNumOuterNeutrals,            Between(52, 52))
  743. #define        (kOuterNeutralPercentLand,        0.68)
  744. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  745. #define        (kOuterNeutralTreePercentage,          0.07)
  746. #define        (kOuterNeutralLandChaos,        0.8)
  747. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  748. #define        (kOuterNeutralFlatChaos,        0.8)
  749. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  750.  
  751. //////////////////////////////////////////////////////////////////////
  752. // resource definitions
  753. #define        (kMaxResourceElevation,            3)
  754. #define        (kResourceToEdgeDistance,        2)
  755. #define        (kResourceToWaterDistance,        4)
  756.  
  757. #define        (kAnimalPerPlayer,            0)
  758. #define        (kAnimalPerNeutral,            0)
  759.  
  760. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  761.   #define  (kBerryPerPlayer,    2)
  762. #else
  763.   #define  (kBerryPerPlayer,    1)
  764. #endif 
  765.  
  766. #define        (kBerryPerNeutral,            0)
  767.  
  768. #define        (kFishPerPlayer,                0)
  769. #define        (kFishPerNeutral,                0)
  770.  
  771. #define        (kGoldPerPlayer,                1)
  772. #define        (kGoldPerNeutral,                24)
  773.  
  774. #define        (kOilPerPlayer,                0)
  775. #define        (kOilPerNeutral,                0)
  776.  
  777. #define        (kSteelPerPlayer,                1)
  778. #define        (kSteelPerNeutral,            24)
  779.  
  780. #define        (kStonePerPlayer,                1)
  781. #define        (kStonePerNeutral,            8)
  782.  
  783. #define        (kTreePerPlayer,                0)
  784. #define        (kTreePerNeutral,                0)
  785.  
  786.  
  787. //////////////////////////////////////////////////////////////////////
  788. // forest definitions
  789. #define        (kForestFreeRadius,                8.0)
  790. #define        (kForestsPerPlayer,                2)
  791. #define        (kForestChaosLevel,                1)
  792. #define        (kMaxClumpsPerForest,                  2)
  793.  
  794. #elif Is9Players
  795. //////////////////////////////////////////////////////////////////////
  796. // 9 PLAYERS...
  797. //////////////////////////////////////////////////////////////////////
  798.  
  799. //////////////////////////////////////////////////////////////////////
  800. // terrain definitions
  801. #if        PERCENT(80)
  802.   #define        (kMaxIntElevation,            10)
  803. #else
  804.   #define        (kMaxIntElevation,            16)
  805. #endif
  806.  
  807. #define        (kElevationScale,                Between(1, 1))
  808. #define        (kHeightMapChaos,                Between(30, 30))
  809.                                             
  810. #define        (kMinimumStartPositionToMapEdge    5)
  811. #define        (kOuterPushFromMapCenter        25)
  812. #define        (kInnerPushFromMapCenter         0)    
  813.     
  814. #define        (kConvergentSampleSize,            32) 
  815. #define        (kConvergentThreshold,            1)    
  816.                                             
  817. //////////////////////////////////////////////////////////////////////
  818. // player definitions
  819. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  820. #define        (kPlayerInnerRadius,            0.6)
  821. #define        (kPlayerOuterRadius,            0.95)
  822. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  823. #define        (kPlayerPercentFlat,            Between(.9, .9))
  824. #define        (kPlayerLandChaos,            0.8)
  825. #define        (kPlayerLandClumps,            Between(2, 2))
  826. #define        (kPlayerFlatChaos,            0.8)
  827. #define        (kPlayerFlatClumps,            Between(1, 2))
  828. #define        (kPlayerTreePercentage,            0.04)
  829.  
  830. //////////////////////////////////////////////////////////////////////
  831. // inner neutral definitions
  832. #define        (kNeutralInnerRadius,            0.2)
  833. #define        (kNeutralOuterRadius,            0.5)
  834. #define        (kNeutralOptimalFactor,            0.7)
  835. #define        (kNumInnerNeutrals,                 Between(22, 22))
  836. #define        (kInnerNeutralPercentLand,        0.19)
  837. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  838. #define        (kInnerNeutralTreePercentage,          0.09)
  839. #define        (kInnerNeutralLandChaos,        0.8)
  840. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  841. #define        (kInnerNeutralFlatChaos,        0.8)
  842. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  843.  
  844. //////////////////////////////////////////////////////////////////////
  845. // outer neutral definitions
  846. #define        (kNumOuterNeutrals,            Between(52, 52))
  847. #define        (kOuterNeutralPercentLand,        0.68)
  848. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  849. #define        (kOuterNeutralTreePercentage,          0.07)
  850. #define        (kOuterNeutralLandChaos,        0.8)
  851. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  852. #define        (kOuterNeutralFlatChaos,        0.8)
  853. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  854.  
  855. //////////////////////////////////////////////////////////////////////
  856. // resource definitions
  857. #define        (kMaxResourceElevation,            3)
  858. #define        (kResourceToEdgeDistance,        2)
  859. #define        (kResourceToWaterDistance,        4)
  860.  
  861. #define        (kAnimalPerPlayer,            0)
  862. #define        (kAnimalPerNeutral,            0)
  863.  
  864. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  865.   #define  (kBerryPerPlayer,    2)
  866. #else
  867.   #define  (kBerryPerPlayer,    1)
  868. #endif 
  869.  
  870. #define        (kBerryPerNeutral,            0)
  871.  
  872. #define        (kFishPerPlayer,                0)
  873. #define        (kFishPerNeutral,                0)
  874.  
  875. #define        (kGoldPerPlayer,                1)
  876. #define        (kGoldPerNeutral,                24)
  877.  
  878. #define        (kOilPerPlayer,                0)
  879. #define        (kOilPerNeutral,                0)
  880.  
  881. #define        (kSteelPerPlayer,                1)
  882. #define        (kSteelPerNeutral,            24)
  883.  
  884. #define        (kStonePerPlayer,                1)
  885. #define        (kStonePerNeutral,            8)
  886.  
  887. #define        (kTreePerPlayer,                0)
  888. #define        (kTreePerNeutral,                0)
  889.  
  890.  
  891. //////////////////////////////////////////////////////////////////////
  892. // forest definitions
  893. #define        (kForestFreeRadius,                8.0)
  894. #define        (kForestsPerPlayer,                2)
  895. #define        (kForestChaosLevel,                1)
  896. #define        (kMaxClumpsPerForest,                  2)
  897.  
  898.  
  899. #elif Is10Players
  900. //////////////////////////////////////////////////////////////////////
  901. // 10 PLAYERS...
  902. //////////////////////////////////////////////////////////////////////
  903.  
  904. //////////////////////////////////////////////////////////////////////
  905. // terrain definitions
  906. #if        PERCENT(80)
  907.   #define        (kMaxIntElevation,            10)
  908. #else
  909.   #define        (kMaxIntElevation,            16)
  910. #endif
  911.  
  912. #define        (kElevationScale,                Between(1, 1))
  913. #define        (kHeightMapChaos,                Between(30, 30))
  914.                                             
  915. #define        (kMinimumStartPositionToMapEdge    5)
  916. #define        (kOuterPushFromMapCenter        25)
  917. #define        (kInnerPushFromMapCenter         0)    
  918.     
  919. #define        (kConvergentSampleSize,            32) 
  920. #define        (kConvergentThreshold,            1)    
  921.                                             
  922. //////////////////////////////////////////////////////////////////////
  923. // player definitions
  924. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  925. #define        (kPlayerInnerRadius,            0.6)
  926. #define        (kPlayerOuterRadius,            0.95)
  927. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  928. #define        (kPlayerPercentFlat,            Between(.9, .9))
  929. #define        (kPlayerLandChaos,            0.8)
  930. #define        (kPlayerLandClumps,            Between(2, 2))
  931. #define        (kPlayerFlatChaos,            0.8)
  932. #define        (kPlayerFlatClumps,            Between(1, 2))
  933. #define        (kPlayerTreePercentage,            0.04)
  934.  
  935. //////////////////////////////////////////////////////////////////////
  936. // inner neutral definitions
  937. #define        (kNeutralInnerRadius,            0.2)
  938. #define        (kNeutralOuterRadius,            0.5)
  939. #define        (kNeutralOptimalFactor,            0.7)
  940. #define        (kNumInnerNeutrals,                 Between(22, 22))
  941. #define        (kInnerNeutralPercentLand,        0.19)
  942. #define        (kInnerNeutralPercentFlat,        Between(0.85, 0.85))
  943. #define        (kInnerNeutralTreePercentage,          0.09)
  944. #define        (kInnerNeutralLandChaos,        0.8)
  945. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  946. #define        (kInnerNeutralFlatChaos,        0.8)
  947. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  948.  
  949. //////////////////////////////////////////////////////////////////////
  950. // outer neutral definitions
  951. #define        (kNumOuterNeutrals,            Between(52, 52))
  952. #define        (kOuterNeutralPercentLand,        0.68)
  953. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  954. #define        (kOuterNeutralTreePercentage,          0.07)
  955. #define        (kOuterNeutralLandChaos,        0.8)
  956. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  957. #define        (kOuterNeutralFlatChaos,        0.8)
  958. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  959.  
  960. //////////////////////////////////////////////////////////////////////
  961. // resource definitions
  962. #define        (kMaxResourceElevation,            3)
  963. #define        (kResourceToEdgeDistance,        2)
  964. #define        (kResourceToWaterDistance,        4)
  965.  
  966. #define        (kAnimalPerPlayer,            0)
  967. #define        (kAnimalPerNeutral,            0)
  968.  
  969. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  970.   #define  (kBerryPerPlayer,    2)
  971. #else
  972.   #define  (kBerryPerPlayer,    1)
  973. #endif 
  974.  
  975. #define        (kBerryPerNeutral,            0)
  976.  
  977. #define        (kFishPerPlayer,                0)
  978. #define        (kFishPerNeutral,                0)
  979.  
  980. #define        (kGoldPerPlayer,                1)
  981. #define        (kGoldPerNeutral,                24)
  982.  
  983. #define        (kOilPerPlayer,                0)
  984. #define        (kOilPerNeutral,                0)
  985.  
  986. #define        (kSteelPerPlayer,                1)
  987. #define        (kSteelPerNeutral,            24)
  988.  
  989. #define        (kStonePerPlayer,                1)
  990. #define        (kStonePerNeutral,            8)
  991.  
  992. #define        (kTreePerPlayer,                0)
  993. #define        (kTreePerNeutral,                0)
  994.  
  995.  
  996. //////////////////////////////////////////////////////////////////////
  997. // forest definitions
  998. #define        (kForestFreeRadius,                8.0)
  999. #define        (kForestsPerPlayer,                2)
  1000. #define        (kForestChaosLevel,                1)
  1001. #define        (kMaxClumpsPerForest,                  2)
  1002.  
  1003.  
  1004. #elif Is11Players
  1005. //////////////////////////////////////////////////////////////////////
  1006. // 11 PLAYERS...
  1007. //////////////////////////////////////////////////////////////////////
  1008.  
  1009. //////////////////////////////////////////////////////////////////////
  1010. // terrain definitions
  1011. #define        (kMaxIntElevation,            15)
  1012. #define        (kElevationScale,                Between(1, 1))
  1013. #define        (kHeightMapChaos,                Between(30, 60))
  1014.  
  1015. #define        (kMinimumStartPositionToMapEdge    2)
  1016. #define        (kOuterPushFromMapCenter        41)
  1017. #define        (kInnerPushFromMapCenter         0)    
  1018.                                             
  1019. //////////////////////////////////////////////////////////////////////
  1020. // player definitions
  1021. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1022. #define        (kPlayerInnerRadius,            0.6)
  1023. #define        (kPlayerOuterRadius,            0.95)
  1024. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1025. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1026. #define        (kPlayerLandChaos,            0.8)
  1027. #define        (kPlayerLandClumps,            Between(2, 2))
  1028. #define        (kPlayerFlatChaos,            0.8)
  1029. #define        (kPlayerFlatClumps,            Between(1, 2))
  1030. #define        (kPlayerTreePercentage,            0.04)
  1031.  
  1032. //////////////////////////////////////////////////////////////////////
  1033. // inner neutral definitions
  1034. #define        (kNeutralInnerRadius,            0.2)
  1035. #define        (kNeutralOuterRadius,            0.5)
  1036. #define        (kNeutralOptimalFactor,            0.7)
  1037. #define        (kNumInnerNeutrals,                 Between(22, 22))
  1038. #define        (kInnerNeutralPercentLand,        0.19)
  1039. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1040. #define        (kInnerNeutralTreePercentage,          0.09)
  1041. #define        (kInnerNeutralLandChaos,        0.8)
  1042. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1043. #define        (kInnerNeutralFlatChaos,        0.8)
  1044. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1045.  
  1046. //////////////////////////////////////////////////////////////////////
  1047. // outer neutral definitions
  1048. #define        (kNumOuterNeutrals,            Between(52, 52))
  1049. #define        (kOuterNeutralPercentLand,        0.68)
  1050. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1051. #define        (kOuterNeutralTreePercentage,          0.07)
  1052. #define        (kOuterNeutralLandChaos,        0.8)
  1053. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1054. #define        (kOuterNeutralFlatChaos,        0.8)
  1055. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1056.  
  1057. //////////////////////////////////////////////////////////////////////
  1058. // resource definitions
  1059. #define        (kMaxResourceElevation,            4)
  1060. #define        (kResourceToEdgeDistance,        2)
  1061. #define        (kResourceToWaterDistance,        4)
  1062.  
  1063. #define        (kAnimalPerPlayer,            0)
  1064. #define        (kAnimalPerNeutral,            0)
  1065.  
  1066. #define        (kBerryPerPlayer,                1)
  1067. #define        (kBerryPerNeutral,            0)
  1068.  
  1069. #define        (kFishPerPlayer,                0)
  1070. #define        (kFishPerNeutral,                0)
  1071.  
  1072. #define        (kGoldPerPlayer,                1)
  1073. #define        (kGoldPerNeutral,                24)
  1074.  
  1075. #define        (kOilPerPlayer,                0)
  1076. #define        (kOilPerNeutral,                0)
  1077.  
  1078. #define        (kSteelPerPlayer,                1)
  1079. #define        (kSteelPerNeutral,            24)
  1080.  
  1081. #define        (kStonePerPlayer,                1)
  1082. #define        (kStonePerNeutral,            8)
  1083.  
  1084. #define        (kTreePerPlayer,                0)
  1085. #define        (kTreePerNeutral,                0)
  1086.  
  1087.  
  1088. //////////////////////////////////////////////////////////////////////
  1089. // forest definitions
  1090. #define        (kForestFreeRadius,                8.0)
  1091. #define        (kForestsPerPlayer,                2)
  1092. #define        (kForestChaosLevel,                0.5)
  1093. #define        (kMaxClumpsPerForest,                  2)
  1094.  
  1095.  
  1096. #elif Is12Players
  1097. //////////////////////////////////////////////////////////////////////
  1098. // 12 PLAYERS...
  1099. //////////////////////////////////////////////////////////////////////
  1100.  
  1101. //////////////////////////////////////////////////////////////////////
  1102. // terrain definitions
  1103. #define        (kMaxIntElevation,            15)
  1104. #define        (kElevationScale,                Between(1, 1))
  1105. #define        (kHeightMapChaos,                Between(30, 60))
  1106.  
  1107. #define        (kMinimumStartPositionToMapEdge    2)
  1108. #define        (kOuterPushFromMapCenter        41)
  1109. #define        (kInnerPushFromMapCenter         0)    
  1110.                                             
  1111. //////////////////////////////////////////////////////////////////////
  1112. // player definitions
  1113. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1114. #define        (kPlayerInnerRadius,            0.6)
  1115. #define        (kPlayerOuterRadius,            0.95)
  1116. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1117. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1118. #define        (kPlayerLandChaos,            0.8)
  1119. #define        (kPlayerLandClumps,            Between(2, 2))
  1120. #define        (kPlayerFlatChaos,            0.8)
  1121. #define        (kPlayerFlatClumps,            Between(1, 2))
  1122. #define        (kPlayerTreePercentage,            0.04)
  1123.  
  1124. //////////////////////////////////////////////////////////////////////
  1125. // inner neutral definitions
  1126. #define        (kNeutralInnerRadius,            0.2)
  1127. #define        (kNeutralOuterRadius,            0.5)
  1128. #define        (kNeutralOptimalFactor,            0.7)
  1129. #define        (kNumInnerNeutrals,                 Between(22, 22))
  1130. #define        (kInnerNeutralPercentLand,        0.19)
  1131. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1132. #define        (kInnerNeutralTreePercentage,          0.09)
  1133. #define        (kInnerNeutralLandChaos,        0.8)
  1134. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1135. #define        (kInnerNeutralFlatChaos,        0.8)
  1136. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1137.  
  1138. //////////////////////////////////////////////////////////////////////
  1139. // outer neutral definitions
  1140. #define        (kNumOuterNeutrals,            Between(52, 52))
  1141. #define        (kOuterNeutralPercentLand,        0.68)
  1142. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1143. #define        (kOuterNeutralTreePercentage,          0.07)
  1144. #define        (kOuterNeutralLandChaos,        0.8)
  1145. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1146. #define        (kOuterNeutralFlatChaos,        0.8)
  1147. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1148.  
  1149. //////////////////////////////////////////////////////////////////////
  1150. // resource definitions
  1151. #define        (kMaxResourceElevation,            4)
  1152. #define        (kResourceToEdgeDistance,        2)
  1153. #define        (kResourceToWaterDistance,        4)
  1154.  
  1155. #define        (kAnimalPerPlayer,            0)
  1156. #define        (kAnimalPerNeutral,            0)
  1157.  
  1158. #define        (kBerryPerPlayer,                1)
  1159. #define        (kBerryPerNeutral,            0)
  1160.  
  1161. #define        (kFishPerPlayer,                0)
  1162. #define        (kFishPerNeutral,                0)
  1163.  
  1164. #define        (kGoldPerPlayer,                1)
  1165. #define        (kGoldPerNeutral,                24)
  1166.  
  1167. #define        (kOilPerPlayer,                0)
  1168. #define        (kOilPerNeutral,                0)
  1169.  
  1170. #define        (kSteelPerPlayer,                1)
  1171. #define        (kSteelPerNeutral,            24)
  1172.  
  1173. #define        (kStonePerPlayer,                1)
  1174. #define        (kStonePerNeutral,            8)
  1175.  
  1176. #define        (kTreePerPlayer,                0)
  1177. #define        (kTreePerNeutral,                0)
  1178.  
  1179.  
  1180. //////////////////////////////////////////////////////////////////////
  1181. // forest definitions
  1182. #define        (kForestFreeRadius,                8.0)
  1183. #define        (kForestsPerPlayer,                2)
  1184. #define        (kForestChaosLevel,                0.5)
  1185. #define        (kMaxClumpsPerForest,                  2)
  1186.  
  1187.  
  1188. #elif Is13Players
  1189. //////////////////////////////////////////////////////////////////////
  1190. // 13 PLAYERS...
  1191. //////////////////////////////////////////////////////////////////////
  1192.  
  1193. //////////////////////////////////////////////////////////////////////
  1194. // terrain definitions
  1195. #define        (kMaxIntElevation,            15)
  1196. #define        (kElevationScale,                Between(1, 1))
  1197. #define        (kHeightMapChaos,                Between(30, 60))
  1198.  
  1199. #define        (kMinimumStartPositionToMapEdge    2)
  1200. #define        (kOuterPushFromMapCenter        41)
  1201. #define        (kInnerPushFromMapCenter         0)    
  1202.                                             
  1203. //////////////////////////////////////////////////////////////////////
  1204. // player definitions
  1205. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1206. #define        (kPlayerInnerRadius,            0.6)
  1207. #define        (kPlayerOuterRadius,            0.95)
  1208. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1209. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1210. #define        (kPlayerLandChaos,            0.8)
  1211. #define        (kPlayerLandClumps,            Between(2, 2))
  1212. #define        (kPlayerFlatChaos,            0.8)
  1213. #define        (kPlayerFlatClumps,            Between(1, 2))
  1214. #define        (kPlayerTreePercentage,            0.04)
  1215.  
  1216. //////////////////////////////////////////////////////////////////////
  1217. // inner neutral definitions
  1218. #define        (kNeutralInnerRadius,            0.2)
  1219. #define        (kNeutralOuterRadius,            0.5)
  1220. #define        (kNeutralOptimalFactor,            0.7)
  1221. #define        (kNumInnerNeutrals,                 Between(22, 22))
  1222. #define        (kInnerNeutralPercentLand,        0.19)
  1223. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1224. #define        (kInnerNeutralTreePercentage,          0.09)
  1225. #define        (kInnerNeutralLandChaos,        0.8)
  1226. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1227. #define        (kInnerNeutralFlatChaos,        0.8)
  1228. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1229.  
  1230. //////////////////////////////////////////////////////////////////////
  1231. // outer neutral definitions
  1232. #define        (kNumOuterNeutrals,            Between(52, 52))
  1233. #define        (kOuterNeutralPercentLand,        0.68)
  1234. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1235. #define        (kOuterNeutralTreePercentage,          0.07)
  1236. #define        (kOuterNeutralLandChaos,        0.8)
  1237. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1238. #define        (kOuterNeutralFlatChaos,        0.8)
  1239. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1240.  
  1241. //////////////////////////////////////////////////////////////////////
  1242. // resource definitions
  1243. #define        (kMaxResourceElevation,            4)
  1244. #define        (kResourceToEdgeDistance,        2)
  1245. #define        (kResourceToWaterDistance,        4)
  1246.  
  1247. #define        (kAnimalPerPlayer,            0)
  1248. #define        (kAnimalPerNeutral,            0)
  1249.  
  1250. #define        (kBerryPerPlayer,                1)
  1251. #define        (kBerryPerNeutral,            0)
  1252.  
  1253. #define        (kFishPerPlayer,                0)
  1254. #define        (kFishPerNeutral,                0)
  1255.  
  1256. #define        (kGoldPerPlayer,                1)
  1257. #define        (kGoldPerNeutral,                24)
  1258.  
  1259. #define        (kOilPerPlayer,                0)
  1260. #define        (kOilPerNeutral,                0)
  1261.  
  1262. #define        (kSteelPerPlayer,                1)
  1263. #define        (kSteelPerNeutral,            24)
  1264.  
  1265. #define        (kStonePerPlayer,                1)
  1266. #define        (kStonePerNeutral,            8)
  1267.  
  1268. #define        (kTreePerPlayer,                0)
  1269. #define        (kTreePerNeutral,                0)
  1270.  
  1271.  
  1272. //////////////////////////////////////////////////////////////////////
  1273. // forest definitions
  1274. #define        (kForestFreeRadius,                8.0)
  1275. #define        (kForestsPerPlayer,                2)
  1276. #define        (kForestChaosLevel,                0.5)
  1277. #define        (kMaxClumpsPerForest,                  2)
  1278.  
  1279.  
  1280. #elif Is14Players
  1281. //////////////////////////////////////////////////////////////////////
  1282. // 14 PLAYERS...
  1283. //////////////////////////////////////////////////////////////////////
  1284.  
  1285. //////////////////////////////////////////////////////////////////////
  1286. // terrain definitions
  1287. #define        (kMaxIntElevation,            15)
  1288. #define        (kElevationScale,                Between(1, 1))
  1289. #define        (kHeightMapChaos,                Between(30, 60))
  1290.  
  1291. #define        (kMinimumStartPositionToMapEdge    2)
  1292. #define        (kOuterPushFromMapCenter        41)
  1293. #define        (kInnerPushFromMapCenter         0)    
  1294.                                             
  1295. //////////////////////////////////////////////////////////////////////
  1296. // player definitions
  1297. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1298. #define        (kPlayerInnerRadius,            0.6)
  1299. #define        (kPlayerOuterRadius,            0.95)
  1300. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1301. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1302. #define        (kPlayerLandChaos,            0.8)
  1303. #define        (kPlayerLandClumps,            Between(2, 2))
  1304. #define        (kPlayerFlatChaos,            0.8)
  1305. #define        (kPlayerFlatClumps,            Between(1, 2))
  1306. #define        (kPlayerTreePercentage,            0.04)
  1307.  
  1308. //////////////////////////////////////////////////////////////////////
  1309. // inner neutral definitions
  1310. #define        (kNeutralInnerRadius,            0.2)
  1311. #define        (kNeutralOuterRadius,            0.5)
  1312. #define        (kNeutralOptimalFactor,            0.7)
  1313. #define        (kNumInnerNeutrals,                 Between(22, 22))
  1314. #define        (kInnerNeutralPercentLand,        0.19)
  1315. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1316. #define        (kInnerNeutralTreePercentage,          0.09)
  1317. #define        (kInnerNeutralLandChaos,        0.8)
  1318. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1319. #define        (kInnerNeutralFlatChaos,        0.8)
  1320. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1321.  
  1322. //////////////////////////////////////////////////////////////////////
  1323. // outer neutral definitions
  1324. #define        (kNumOuterNeutrals,            Between(52, 52))
  1325. #define        (kOuterNeutralPercentLand,        0.68)
  1326. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1327. #define        (kOuterNeutralTreePercentage,          0.07)
  1328. #define        (kOuterNeutralLandChaos,        0.8)
  1329. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1330. #define        (kOuterNeutralFlatChaos,        0.8)
  1331. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1332.  
  1333. //////////////////////////////////////////////////////////////////////
  1334. // resource definitions
  1335. #define        (kMaxResourceElevation,            4)
  1336. #define        (kResourceToEdgeDistance,        2)
  1337. #define        (kResourceToWaterDistance,        4)
  1338.  
  1339. #define        (kAnimalPerPlayer,            0)
  1340. #define        (kAnimalPerNeutral,            0)
  1341.  
  1342. #define        (kBerryPerPlayer,                1)
  1343. #define        (kBerryPerNeutral,            0)
  1344.  
  1345. #define        (kFishPerPlayer,                0)
  1346. #define        (kFishPerNeutral,                0)
  1347.  
  1348. #define        (kGoldPerPlayer,                1)
  1349. #define        (kGoldPerNeutral,                24)
  1350.  
  1351. #define        (kOilPerPlayer,                0)
  1352. #define        (kOilPerNeutral,                0)
  1353.  
  1354. #define        (kSteelPerPlayer,                1)
  1355. #define        (kSteelPerNeutral,            24)
  1356.  
  1357. #define        (kStonePerPlayer,                1)
  1358. #define        (kStonePerNeutral,            8)
  1359.  
  1360. #define        (kTreePerPlayer,                0)
  1361. #define        (kTreePerNeutral,                0)
  1362.  
  1363.  
  1364. //////////////////////////////////////////////////////////////////////
  1365. // forest definitions
  1366. #define        (kForestFreeRadius,                8.0)
  1367. #define        (kForestsPerPlayer,                2)
  1368. #define        (kForestChaosLevel,                0.5)
  1369. #define        (kMaxClumpsPerForest,                  2)
  1370.  
  1371.  
  1372. #elif Is15Players
  1373. //////////////////////////////////////////////////////////////////////
  1374. // 15 PLAYERS...
  1375. //////////////////////////////////////////////////////////////////////
  1376.  
  1377. //////////////////////////////////////////////////////////////////////
  1378. // terrain definitions
  1379. #define        (kMaxIntElevation,            15)
  1380. #define        (kElevationScale,                Between(1, 1))
  1381. #define        (kHeightMapChaos,                Between(30, 60))
  1382.  
  1383. #define        (kMinimumStartPositionToMapEdge    2)
  1384. #define        (kOuterPushFromMapCenter        41)
  1385. #define        (kInnerPushFromMapCenter         0)    
  1386.                                             
  1387. //////////////////////////////////////////////////////////////////////
  1388. // player definitions
  1389. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1390. #define        (kPlayerInnerRadius,            0.6)
  1391. #define        (kPlayerOuterRadius,            0.95)
  1392. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1393. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1394. #define        (kPlayerLandChaos,            0.8)
  1395. #define        (kPlayerLandClumps,            Between(2, 2))
  1396. #define        (kPlayerFlatChaos,            0.8)
  1397. #define        (kPlayerFlatClumps,            Between(1, 2))
  1398. #define        (kPlayerTreePercentage,            0.04)
  1399.  
  1400. //////////////////////////////////////////////////////////////////////
  1401. // inner neutral definitions
  1402. #define        (kNeutralInnerRadius,            0.2)
  1403. #define        (kNeutralOuterRadius,            0.5)
  1404. #define        (kNeutralOptimalFactor,            0.7)
  1405. #define        (kNumInnerNeutrals,                 Between(22, 22))
  1406. #define        (kInnerNeutralPercentLand,        0.19)
  1407. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1408. #define        (kInnerNeutralTreePercentage,          0.09)
  1409. #define        (kInnerNeutralLandChaos,        0.8)
  1410. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1411. #define        (kInnerNeutralFlatChaos,        0.8)
  1412. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1413.  
  1414. //////////////////////////////////////////////////////////////////////
  1415. // outer neutral definitions
  1416. #define        (kNumOuterNeutrals,            Between(52, 52))
  1417. #define        (kOuterNeutralPercentLand,        0.68)
  1418. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1419. #define        (kOuterNeutralTreePercentage,          0.07)
  1420. #define        (kOuterNeutralLandChaos,        0.8)
  1421. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1422. #define        (kOuterNeutralFlatChaos,        0.8)
  1423. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1424.  
  1425. //////////////////////////////////////////////////////////////////////
  1426. // resource definitions
  1427. #define        (kMaxResourceElevation,            4)
  1428. #define        (kResourceToEdgeDistance,        2)
  1429. #define        (kResourceToWaterDistance,        4)
  1430.  
  1431. #define        (kAnimalPerPlayer,            0)
  1432. #define        (kAnimalPerNeutral,            0)
  1433.  
  1434. #define        (kBerryPerPlayer,                1)
  1435. #define        (kBerryPerNeutral,            0)
  1436.  
  1437. #define        (kFishPerPlayer,                0)
  1438. #define        (kFishPerNeutral,                0)
  1439.  
  1440. #define        (kGoldPerPlayer,                1)
  1441. #define        (kGoldPerNeutral,                24)
  1442.  
  1443. #define        (kOilPerPlayer,                0)
  1444. #define        (kOilPerNeutral,                0)
  1445.  
  1446. #define        (kSteelPerPlayer,                1)
  1447. #define        (kSteelPerNeutral,            24)
  1448.  
  1449. #define        (kStonePerPlayer,                1)
  1450. #define        (kStonePerNeutral,            8)
  1451.  
  1452. #define        (kTreePerPlayer,                0)
  1453. #define        (kTreePerNeutral,                0)
  1454.  
  1455.  
  1456. //////////////////////////////////////////////////////////////////////
  1457. // forest definitions
  1458. #define        (kForestFreeRadius,                8.0)
  1459. #define        (kForestsPerPlayer,                2)
  1460. #define        (kForestChaosLevel,                0.5)
  1461. #define        (kMaxClumpsPerForest,                  2)
  1462.  
  1463.  
  1464. #elif Is16Players
  1465. //////////////////////////////////////////////////////////////////////
  1466. // 16 PLAYERS...
  1467. //////////////////////////////////////////////////////////////////////
  1468.  
  1469. //////////////////////////////////////////////////////////////////////
  1470. // terrain definitions
  1471. #define        (kMaxIntElevation,            15)
  1472. #define        (kElevationScale,                Between(1, 1))
  1473. #define        (kHeightMapChaos,                Between(30, 60))
  1474.  
  1475. #define        (kMinimumStartPositionToMapEdge    2)
  1476. #define        (kOuterPushFromMapCenter        41)
  1477. #define        (kInnerPushFromMapCenter         0)    
  1478.                                             
  1479. //////////////////////////////////////////////////////////////////////
  1480. // player definitions
  1481. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1482. #define        (kPlayerInnerRadius,            0.6)
  1483. #define        (kPlayerOuterRadius,            0.95)
  1484. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1485. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1486. #define        (kPlayerLandChaos,            0.8)
  1487. #define        (kPlayerLandClumps,            Between(2, 2))
  1488. #define        (kPlayerFlatChaos,            0.8)
  1489. #define        (kPlayerFlatClumps,            Between(1, 2))
  1490. #define        (kPlayerTreePercentage,            0.04)
  1491.  
  1492. //////////////////////////////////////////////////////////////////////
  1493. // inner neutral definitions
  1494. #define        (kNeutralInnerRadius,            0.2)
  1495. #define        (kNeutralOuterRadius,            0.5)
  1496. #define        (kNeutralOptimalFactor,            0.7)
  1497. #define        (kNumInnerNeutrals,                 Between(22, 22))
  1498. #define        (kInnerNeutralPercentLand,        0.19)
  1499. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1500. #define        (kInnerNeutralTreePercentage,          0.09)
  1501. #define        (kInnerNeutralLandChaos,        0.8)
  1502. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1503. #define        (kInnerNeutralFlatChaos,        0.8)
  1504. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1505.  
  1506. //////////////////////////////////////////////////////////////////////
  1507. // outer neutral definitions
  1508. #define        (kNumOuterNeutrals,            Between(52, 52))
  1509. #define        (kOuterNeutralPercentLand,        0.68)
  1510. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1511. #define        (kOuterNeutralTreePercentage,          0.07)
  1512. #define        (kOuterNeutralLandChaos,        0.8)
  1513. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1514. #define        (kOuterNeutralFlatChaos,        0.8)
  1515. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1516.  
  1517. //////////////////////////////////////////////////////////////////////
  1518. // resource definitions
  1519. #define        (kMaxResourceElevation,            4)
  1520. #define        (kResourceToEdgeDistance,        2)
  1521. #define        (kResourceToWaterDistance,        4)
  1522.  
  1523. #define        (kAnimalPerPlayer,            0)
  1524. #define        (kAnimalPerNeutral,            0)
  1525.  
  1526. #define        (kBerryPerPlayer,                1)
  1527. #define        (kBerryPerNeutral,            0)
  1528.  
  1529. #define        (kFishPerPlayer,                0)
  1530. #define        (kFishPerNeutral,                0)
  1531.  
  1532. #define        (kGoldPerPlayer,                1)
  1533. #define        (kGoldPerNeutral,                24)
  1534.  
  1535. #define        (kOilPerPlayer,                0)
  1536. #define        (kOilPerNeutral,                0)
  1537.  
  1538. #define        (kSteelPerPlayer,                1)
  1539. #define        (kSteelPerNeutral,            24)
  1540.  
  1541. #define        (kStonePerPlayer,                1)
  1542. #define        (kStonePerNeutral,            8)
  1543.  
  1544. #define        (kTreePerPlayer,                0)
  1545. #define        (kTreePerNeutral,                0)
  1546.  
  1547.  
  1548. //////////////////////////////////////////////////////////////////////
  1549. // forest definitions
  1550. #define        (kForestFreeRadius,                8.0)
  1551. #define        (kForestsPerPlayer,                2)
  1552. #define        (kForestChaosLevel,                0.5)
  1553. #define        (kMaxClumpsPerForest,                  2)
  1554.  
  1555.  
  1556. //////////////////////////////////////////////////////////////////////
  1557. // End of if...elif... command
  1558. #endif
  1559.  
  1560. #endif        // NOTDEFINED(HIGHLANDS_GIGANTIC_RMV)
  1561.